{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 黄奕铭组py课设（黄奕铭 刘佳琦 贾卓霖 孙海川）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总体思路与介绍\n",
    "![image-20220523030947614](index.assets/image-20220523030947614.png)\n",
    "* 框架\n",
    "    * 模型：pytorch sklearn gensim \n",
    "    * 数据处理 numpy matplotlib pandas pymysql\n",
    "    * 爬虫 scrapy selenium"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 环境配置与爬虫"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 爬虫\n",
    "* 分为股票爬虫和金融爬虫\n",
    "* 采用的是scrapy（流水线处理数据） + selenium（具体爬取）+ mysql（存储数据）框架\n",
    "* ![image-20220523111115041](index.assets/image-20220523111115041.png)  \n",
    "   总体来说就是现代开发中的依赖注入、控制反转（IOC）的思想，具体表现为实现自己的item为爬取实体（如stockitem、sentiitem）和数据库中的属性相同, 对不同的爬取实体实现spider可以融合其他爬取库进行爬取，核心方法是实现parse方法，pipline要处理爬取的item清洗后存入database，核心方法是实现process_item方法 \n",
    "* 一些注意的点\n",
    "  * setting.py中进行配置（是否遵循robots.txt、pipeline的优先级、打印日志的等级、mysql的配置）\n",
    "  * 因为爬取是需要时间的，而且尤其是selenium框架跳转的速度并没有想像的高（当然，这可能是没有自己去实现download midderware的缘故吧），所以要做以下两个处理\n",
    "      * selenium的webdriver要进行等待，这里选择的是隐式等待\n",
    "      * pipeline要进行异步处理，不能直接调pymysql"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 股票爬虫\n",
    "* 定位爬取的核心方法就一个\n",
    "```find_element（s）_by_xpath() + //[@name/class/id='xxx']/```\n",
    "* 还要对搜索框进行输入、点击、换页send_keys, handles标签页数组\n",
    "* 股票爬虫的目标\n",
    "    ![image-20220529193824610](index.assets/image-20220529193824610.png)\n",
    "* 股票爬虫成功爬入数据库mysql\n",
    "    ![image-20220523110424678](index.assets/image-20220523110424678.png)\n",
    "* 命令行需要股票代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!scrapy crawl stock -a tscode='000065'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 金融舆评爬取\n",
    "* ![image-20220419091647054](index.assets/image-20220419091647054.png)\n",
    "* ![image-20220529194333032](index.assets/image-20220529194333032.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!scrapy crawl senti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### http 封装\n",
    "* 项目需要，前端vue直接通过axios向后端请求爬取\n",
    "* 打印日志\n",
    "![image-20220529200347714](index.assets/image-20220529200347714.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"status\": \"ok\", \"items\": [null], \"items_dropped\": [], \"stats\": {\"downloader/request_bytes\": 728, \"downloader/request_count\": 3, \"downloader/request_method_count/GET\": 3, \"downloader/response_bytes\": 120907, \"downloader/response_count\": 3, \"downloader/response_status_count/200\": 1, \"downloader/response_status_count/301\": 2, \"elapsed_time_seconds\": 5.724448, \"finish_reason\": \"finished\", \"finish_time\": \"2022-05-29 12:02:02\", \"item_scraped_count\": 1, \"log_count/DEBUG\": 86, \"log_count/INFO\": 9, \"response_received_count\": 1, \"scheduler/dequeued\": 3, \"scheduler/dequeued/memory\": 3, \"scheduler/enqueued\": 3, \"scheduler/enqueued/memory\": 3, \"start_time\": \"2022-05-29 12:01:56\"}, \"spider_name\": \"stock\"}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "\n",
      "  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:01 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:02 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:03 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:04 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:05 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:06 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:07 --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:08 --:--:--     0\n",
      "100   702  100   702    0     0     79      0  0:00:08  0:00:08 --:--:--   153\n",
      "100   702  100   702    0     0     79      0  0:00:08  0:00:08 --:--:--   197\n"
     ]
    }
   ],
   "source": [
    "#目标文件夹\n",
    "!scrapyrt\n",
    "!curl \"http://localhost:9080/crawl.json?spider_name=stock&crawl_args=%7B%22tscode%22%3A%20%22000065%22%7D&url=https://finance.ifeng.com/app/hq/stock/sh000001\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import sklearn\n",
    "import scrapy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 时间序列预测RNN网络\n",
    "* 为什么只训练了一个网络，因为我们认为 $S_{x_{t_{n+1}}} = F_{x}({S_{x_{t_{1}}}...S_{x_{t_{n}}}}), F_x <=> F_{x^{'}}$, 即所有不同股票当前收盘价与之前的时间序列满足同一个分布（当然，仅在几轮的训练中证明这个假设可能过于草率）\n",
    "* ![image-20220519120057845](index.assets/image-20220519120057845.png)\n",
    "* 短网络\n",
    " ![image-20220519120355873](index.assets/image-20220519120355873.png)\n",
    "* 长网络\n",
    " ![image-20220519144833416](index.assets/image-20220519144833416.png)\n",
    "* LSTM计算机制\n",
    " ![image-20220519144807618](index.assets/image-20220519144807618.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class StockNetS(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.r1 = nn.RNN(10, 20, 1)\n",
    "        self.r2 = nn.RNN(20, 20, 2)\n",
    "        self.r3 = nn.RNN(20, 10, 1)\n",
    "        self.l1 = nn.Linear(10, 10)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x, _ = self.r1(x)\n",
    "        x, _ = self.r2(x)\n",
    "        x, _ = self.r3(x)\n",
    "        x = self.l1(x)\n",
    "        return x\n",
    "    \n",
    "class StockNetL(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.r1 = nn.LSTM(100, 110, 1)\n",
    "        self.r2 = nn.LSTM(110, 110, 1)\n",
    "        self.r3 = nn.LSTM(110, 10, 1)\n",
    "        self.l1 = nn.Linear(10, 10)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x, _ = self.r1(x)\n",
    "        x, _ = self.r2(x)\n",
    "        x, _ = self.r3(x)\n",
    "        x = self.l1(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 时间序列数据集部分\n",
    "* 长短两种数据集都涉及了\n",
    "* 采自开源的tushare网站的沪市约4千条股票数据进行训练\n",
    "* ![image-20220523032427453](index.assets/image-20220523032427453.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader, Dataset\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import openpyxl\n",
    "import xlrd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import openpyxl\n",
    "\n",
    "class StockData(Dataset):\n",
    "    def __init__(self, mode):\n",
    "        super().__init__()\n",
    "        fileNames = [\"./stocks2/\" + i for i in os.listdir(\"./stocks2\")]\n",
    "        self.fileNames = []\n",
    "        self.mode = mode\n",
    "        \n",
    "        for f in fileNames:\n",
    "            table = pd.read_excel(f, engine='openpyxl')\n",
    "            if len(table['close']) > 550:\n",
    "                self.fileNames.append(f)\n",
    "    \n",
    "    def __len__(self):\n",
    "        if self.mode == 'Long':\n",
    "            return 5 * len(self.fileNames)\n",
    "        else:\n",
    "            return 25 * len(self.fileNames)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        Index = index\n",
    "        if self.mode == 'Long':\n",
    "            Index = Index // 5\n",
    "        else:\n",
    "            Index = Index // 25\n",
    "        table = pd.read_excel(self.fileNames[Index])\n",
    "        table = np.array(table['close'])\n",
    "        x, y, x_s, y_s = None, None, None, None\n",
    "        start = None\n",
    "        \n",
    "        if self.mode == 'Long':\n",
    "            start = index // 5 + index % 5\n",
    "            x_s, y_s = 100, 10\n",
    "        else:\n",
    "            start = index // 25 + index % 25\n",
    "            x_s = y_s = 10\n",
    "        \n",
    "        x = torch.tensor(table[start: start + x_s], dtype=torch.float32).reshape(1, x_s)\n",
    "        y = torch.tensor(table[start + x_s: start + x_s + y_s], dtype=torch.float32).reshape(1, y_s)\n",
    "        return x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 保存、转换与读取\n",
    "* ![image-20220523030753277](index.assets/image-20220523030753277.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Save(model, name):\n",
    "    torch.save(model.state_dict(), \"./{}.pth\".format(name))\n",
    "    \n",
    "def Load(model, filePath):\n",
    "    model.load_state_dict(torch.load(filePath,  map_location=torch.device('cpu')))\n",
    "    \n",
    "def toOnnx(model, dummy, name):\n",
    "    torch.onnx.export(model, dummy, name, opset_version=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\new_12\\lib\\site-packages\\torch\\onnx\\symbolic_opset9.py:1932: UserWarning: Exporting a model to ONNX with a batch_size other than 1, with a variable length with RNN_TANH can cause an error when running the ONNX model with a different batch size. Make sure to save the model with a batch size of 1, or define the initial states (h0/c0) as inputs of the model. \n",
      "  warnings.warn(\"Exporting a model to ONNX with a batch_size other than 1, \" +\n",
      "D:\\new_12\\lib\\site-packages\\torch\\onnx\\symbolic_opset9.py:1932: UserWarning: Exporting a model to ONNX with a batch_size other than 1, with a variable length with LSTM can cause an error when running the ONNX model with a different batch size. Make sure to save the model with a batch size of 1, or define the initial states (h0/c0) as inputs of the model. \n",
      "  warnings.warn(\"Exporting a model to ONNX with a batch_size other than 1, \" +\n"
     ]
    }
   ],
   "source": [
    "m1 = StockNetS()\n",
    "m2 = StockNetL()\n",
    "d1 = torch.rand(1, 1, 10)\n",
    "d2 = torch.rand(1, 1, 100)\n",
    "toOnnx(m1, d1, \"rnnL.onnx\")\n",
    "toOnnx(m2, d2, \"rnnS.onnx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练\n",
    "* 采用的是 MSE 平均平方损失函数和 Adam优化器进行优化 \n",
    "    $ Loss = (y - y_{predict})^2 / 2 $\n",
    "* Adam是2015ICLR(1412.6980)上提出的目前用的最广的, 本质上就是RMSprop + 动量法的结合，RMSprop以指数衰减加权平均的想法去掉了维度不同间的单位学习率不同与过早衰减，而动量法则是对用负梯度的加权移动平均保证了优化方向后在高维空间的陡坡上往最速降线下降，而到了大量局部鞍点的地方不至于陷入局部min\n",
    "![image-20220528015330386](index.assets/image-20220528015330386.png)\n",
    "* 准确率定义为平均相对误差$ Er = \\delta / S_真 $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stockTrain(epochs, stockData, model, saveDir):\n",
    "    devices = [torch.device(f'cuda:{i}') for i in range(torch.cuda.device_count())]\n",
    "    optimizer = torch.optim.Adam(model.parameters(), 0.1)\n",
    "    criteria = nn.MSELoss()\n",
    "    stockDataLoader = DataLoader(stockData, batch_size=1, shuffle=True, num_workers=0)\n",
    "    model = nn.DataParallel(model, device_ids=devices)\n",
    "    Loss, Error = 0.0, 0.0\n",
    "    cnt = 0\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        for i, (x, y) in enumerate(stockDataLoader):\n",
    "            #x, y  = x.to(devices[0]), y.to(devices[0])\n",
    "            y_ = model(x)\n",
    "\n",
    "            if i % 10 != 0:\n",
    "                loss = criteria(y_, y)\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "            else:\n",
    "                model.eval()\n",
    "                loss = criteria(y_, y)\n",
    "                error =  torch.abs(y_ - y) / torch.abs(y)\n",
    "                Loss += loss\n",
    "                Error +=  error.sum() / len(error)\n",
    "                cnt += 1\n",
    "            \n",
    "        print(\"epoch:{}/{}, loss:{:.2f}, error:{:.2%}\".format(epoch + 1, epochs, Loss / cnt, Error / cnt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 导出的onnx模型\n",
    "![image-20220530102239020](index.assets/image-20220530102239020.png)\n",
    "* 短网络的误差平均上有两倍多\n",
    " ![image-20220523030528806](index.assets/image-20220523030528806.png)\n",
    "* 长网络也是\n",
    " ![image-20220523030658356](index.assets/image-20220523030658356.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 推理\n",
    "* 只爬本日的股价，采用的是用白噪声填充短网络的输入，原理是一个分布的变量族分别对应加上另一个正态方差同样的正态分布一起\n",
    "* 然后使用短网络输出长网络的输入值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stockInfer(Lmodel, Smodel, closeVal):\n",
    "    dummy = torch.rand(10) * closeVal + torch.ones(10) *closeVal\n",
    "    dummys = []\n",
    "    dummys.append(dummy.reshape(1, 1, len(dummy)))\n",
    "    \n",
    "    for i in range(9):\n",
    "        dummys.append(Smodel(dummys[-1]))\n",
    "    \n",
    "    y = Lmodel(torch.cat(dummys, 2))\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 评估\n",
    "* 选取一支股票进行可视化评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1bcb5425190>]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "myNet1 = StockNetS()\n",
    "#Load(myNet1, \"./rnn19.pth\")\n",
    "before = np.array([19.15, 18.98, 17.48, 17.77, 17.41, 17.48, 17.91, 17.58, 16.8, 19.2])\n",
    "after = np.array([17.45, 16.68, 15.51, 14.8, 16.09, 16.65, 16.77, 16.98, 17.67, 18.54])\n",
    "\n",
    "predict = myNet1(torch.tensor([[before]], dtype=torch.float32)).reshape(10).detach().numpy()\n",
    "plt.plot(np.arange(10, 20), after, \"r\", marker='*', ms=10, label=\"a\")\n",
    "plt.plot(np.arange(10, 20), predict, \"r\", marker='^', ms=10, label=\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 情感分类\n",
    "* 《attention is all you need》NIPS2017，开启attention时代的神作，也是对不定长输入进行处理\n",
    "* ![image-20220520151258927](index.assets/image-20220520151258927.png)\n",
    "### 数据预处理与数据集\n",
    "* 先进行分词，使用jieba库将句子改为词序列\n",
    "* 分词过程为去掉停用词、去掉标点, 哈工大scir的停用词表\n",
    "* 然后对进行词嵌入变为词向量，JMLR 2003和2011 NLP的经典模型 skip-gram 和 c-bow模型\n",
    "![image-20220522231114800](index.assets/image-20220522231114800.png)\n",
    "* 这里采用的是ACL2018(人大北师大1805.06504)的一篇论文，使用gensim的word2vec加载预训练的, 预训练的word2vec模型使用的数据集是知乎数据集\n",
    "  ![image-20220522124915042](index.assets/image-20220522124915042.png)\n",
    "* 数据集来源于weibo4moods（30万条）\n",
    "   ![image-20220523134222539](index.assets/image-20220523134222539.png)\n",
    "   ![image-20220522132748121](index.assets/image-20220522132748121.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import word2vec\n",
    "from gensim.models.keyedvectors import KeyedVectors\n",
    "import jieba\n",
    "\n",
    "w2v = KeyedVectors.load_word2vec_format(\"./sgns.zhihu.word.bz2\", binary=False, unicode_errors='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def load_stopword():\n",
    "    f_stop = open('hit_stopwords.txt', encoding='utf-8')  # 自己的中文停用词表\n",
    "    sw = [line.strip() for line in f_stop]  # strip() 方法用于移除字符串头尾指定的字符（默认为空格）\n",
    "    f_stop.close()\n",
    "    return sw\n",
    "\n",
    "def wash_punct(sentence):\n",
    "    remove_chars = '[·’!\"\\#$%&\\'()＃！（）*+,-./:;<=>?\\@，：?￥★、…．＞【】［］《》？“”‘’\\[\\\\]^_`{|}~]+'\n",
    "    string = re.sub(remove_chars, \"\", sentence)\n",
    "    return string\n",
    "\n",
    "def seg_word(sentence):\n",
    "    words = jieba.lcut(sentence)\n",
    "    stops = load_stopword()\n",
    "    fix_words = []\n",
    "    \n",
    "    for word in words:\n",
    "        if word not in stops:\n",
    "            fix_words.append(wash_punct(word))\n",
    "    \n",
    "    return fix_words\n",
    "    \n",
    "def words2vecs(sentences):\n",
    "    vecs = []\n",
    "    \n",
    "    for sentence in sentences:\n",
    "        try:\n",
    "            vecs.append(w2v.word_vec(sentence))\n",
    "        except:\n",
    "            vecs.append(np.zeros(300))\n",
    "    \n",
    "    return vecs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 词向量的意义\n",
    "* 以食物的好吃（美味程度）、贵（价格）、健康为三个维度，对食物词向量基于知乎数据集训练的词嵌入模型进行了聚类，采用的是欧几里德距离，一范数，即$||x||_1$\n",
    "* 本质上是高维空间向低维空间进行一种投影（300维->3维）, 等价于我们做了和PCA类似的事情"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "烤肉 type: 1\n",
      "鸡蛋 type: 1\n",
      "牛奶 type: 1\n",
      "苹果 type: 0\n",
      "香蕉 type: 2\n",
      "汉堡 type: 2\n",
      "可乐 type: 0\n",
      "牛排 type: 0\n",
      "烧麦 type: 0\n",
      "寿司 type: 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "%matplotlib inline\n",
    "\n",
    "def cacuNorm(name, attr):\n",
    "    return np.abs(w2v.get_vector(name) - w2v.get_vector(attr)).sum()\n",
    "\n",
    "foodstr = \"烤肉、鸡蛋、牛奶、苹果、香蕉、汉堡、可乐、牛排、烧麦、寿司\"\n",
    "foodList = foodstr.split(\"、\")\n",
    "\n",
    "socreList = [[cacuNorm(i, \"好吃\") for i in foodList],\n",
    "             [cacuNorm(i, \"贵\") for i in foodList],\n",
    "             [cacuNorm(i, \"健康\") for i in foodList]]\n",
    "\n",
    "model = KMeans(n_clusters=3)\n",
    "pre = model.fit_predict(np.array(socreList).reshape(10, 3))\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.scatter3D(socreList[0], socreList[1], socreList[2], c=pre)\n",
    "plt.xlabel(\"yummy\")\n",
    "plt.ylabel(\"expensive\")\n",
    "ax.set_zlabel(\"healthy\")\n",
    "ax.set_title(\"custom food we like\")\n",
    "x = 0\n",
    "\n",
    "for i in range(len(foodList)):\n",
    "    print(foodList[i], \"type:\", pre[i], end=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class weiboSet(Dataset):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.rawData = pd.read_csv(\"./sim2.csv\")\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.rawData['review'])\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        x = torch.tensor(words2vecs(seg_word(self.rawData['review'][index])), dtype=torch.float32)\n",
    "        y = None\n",
    "        try:\n",
    "            y = torch.tensor(self.rawData['label'][index], dtype=torch.long)\n",
    "        except:\n",
    "            y = torch.tensor(0, dtype=torch.long)\n",
    "        return x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 模型\n",
    "* 采用的是encoder部分, 接受任意长的feature序列\n",
    "![image-20220530103530475](index.assets/image-20220530103530475.png)\n",
    "![image-20220530103730250](index.assets/image-20220530103730250.png)\n",
    "\n",
    "* 输入维度维度为300维\n",
    "* 自然语言有其上下文属性context，要顾及前后的信息，故要位置编码position encoding\n",
    "    ![image-20220522125255585](index.assets/image-20220522125255585.png)\n",
    "* 亮点在于我对于attention encode过后的信息进行了一次线性变换，变换为了4 * x维 + 对长x的第二维取平均应对不定长输入利于分类，当然了，我现在的想法是加一些skip connection会不会效果更好\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class PositionalEncoding(nn.Module):\n",
    "    \"Implement the PE function.\"\n",
    "    def __init__(self, d_model, dropout, max_len=5000):\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        # Compute the positional encodings once in log space.\n",
    "        pe = torch.zeros(max_len, d_model)\n",
    "        position = torch.arange(0, max_len).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2) *\n",
    "                             -(math.log(10000.0) / d_model))\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        pe = pe.unsqueeze(0)\n",
    "        self.register_buffer('pe', pe)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x + self.pe[:, :x.size(1)]\n",
    "        return self.dropout(x)\n",
    "\n",
    "class SentimentTransformer(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        encoder_layer = nn.TransformerEncoderLayer(d_model=300, nhead=6)\n",
    "        self.pos = PositionalEncoding(300, 0.1)\n",
    "        self.trans = nn.TransformerEncoder(encoder_layer, num_layers=6)\n",
    "        self.l1 = nn.Linear(300, 4)\n",
    "        self.cls = nn.Softmax()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.pos(x)\n",
    "        x = self.trans(x)\n",
    "        x = self.l1(x)\n",
    "        x = x.sum(1) / x.size(1)\n",
    "        x = self.cls(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练情感分类模型\n",
    "* 显然，既然是分类，那必然是交叉熵损失函数CrossEntropyLoss\n",
    "* ![image-20220523135910765](index.assets/image-20220523135910765.png)\n",
    "二分之一的正确率（原因是费用问题我只跑了一轮, 另一个问题在于学习率调整策略不合理）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sentimentTrain(epochs, sentiData, model, saveDir):\n",
    "    devices = [torch.device(f'cuda:{i}') for i in range(torch.cuda.device_count())]\n",
    "    optimizer = torch.optim.Adam(model.parameters(), 0.01)\n",
    "    criteria = nn.CrossEntropyLoss()\n",
    "    stockDataLoader = DataLoader(sentiData, batch_size=1, shuffle=True, num_workers=0)\n",
    "    model = nn.DataParallel(model, device_ids=devices)\n",
    "    Loss, Error = 0.0, 0.0\n",
    "    cnt = 0\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        for i, (x, y) in enumerate(stockDataLoader):\n",
    "            #x, y  = x.to(devices[0]), y.to(devices[0])\n",
    "            y_ = model(x)\n",
    "\n",
    "            if i % 10 != 0:\n",
    "                loss = criteria(y_, y)\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "            else:\n",
    "                model.eval()\n",
    "                loss = criteria(y_, y)\n",
    "                _, predicted = torch.max(y_, 1)\n",
    "                error = (predicted != y).sum()\n",
    "                Loss += loss\n",
    "                Error += error\n",
    "                cnt += 1\n",
    "            \n",
    "        print(\"epoch:{}/{}, loss:{:.2f}, error:{:.2%}\".format(epoch + 1, epochs, Loss / cnt, Error / cnt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估\n",
    "* 直接用标签进行评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "喜悦 真值： 0 tensor(0)\n",
      "愤怒 真值： 1 tensor(0)\n",
      "厌恶 真值： 2 tensor(0)\n",
      "低落 真值： 3 tensor(3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-35-3861234c8629>:36: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  x = self.cls(x)\n"
     ]
    }
   ],
   "source": [
    "myModel = SentimentTransformer()\n",
    "Load(myModel, \"./trans1.pth\")\n",
    "myData3 = weiboSet()\n",
    "v4 = [w2v.get_vector(\"喜悦\"), w2v.get_vector(\"愤怒\"), w2v.get_vector(\"厌恶\"), w2v.get_vector(\"低落\")]\n",
    "a1 = myModel(torch.tensor([[v4[0]]], dtype=torch.float32)).argmax()\n",
    "a2 = myModel(torch.tensor([[v4[1]]], dtype=torch.float32)).argmax()\n",
    "a3 = myModel(torch.tensor([[v4[2]]], dtype=torch.float32)).argmax()\n",
    "a4 = myModel(torch.tensor([[v4[3]]], dtype=torch.float32)).argmax()\n",
    "print(\"喜悦\", \"真值：\", 0, a1)\n",
    "print(\"愤怒\", \"真值：\", 1, a2)\n",
    "print(\"厌恶\", \"真值：\", 2, a3)\n",
    "print(\"低落\", \"真值：\", 3, a4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 图灵测试liked评估 + 词云可视化\n",
    "> 如果它\\他\\她的行为像一只鸭子，那么它\\他\\她就是一只鸭子 （duck type）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\86150\\AppData\\Local\\Temp\\ipykernel_10560\\3258421774.py:30: DeprecationWarning: Call to deprecated `word_vec` (Use get_vector instead).\n",
      "  vecs.append(w2v.word_vec(sentence))\n",
      "C:\\Users\\86150\\AppData\\Local\\Temp\\ipykernel_10560\\2994683936.py:36: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  x = self.cls(x)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x26409b204f0>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAADKUlEQVR4nO3UMQEAIAzAMMC/5+GiHCQKenXPzAKgcV4HAPzEdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIHQBcjcEy3+fc28AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import wordcloud\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.rcParams['font.family'] = ['sans-serif']\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "\n",
    "myModel = SentimentTransformer()\n",
    "Load(myModel, \"./trans1.pth\")\n",
    "wc = wordcloud.WordCloud(font_path = 'C:/Windows/Fonts/simfang.ttf', background_color='white')\n",
    "\n",
    "testStr = \"藤本树，我的超人\" # 喜悦\n",
    "testStr2 = \"错的不是我，是这个世界\" # ？厌恶 or 低落\n",
    "testStr3 = \"我是神里绫华的狗\" # 喜悦\n",
    "testStr4 = \"homo特有的急性子（恼）\" # 愤怒\n",
    "                         \n",
    "labels = [\"喜悦\", \"愤怒\", \"厌恶\", \"低落\"]\n",
    "a = myModel(torch.tensor([words2vecs(seg_word(testStr))], dtype=torch.float32)).detach().numpy()[0]#.argmax()\n",
    "b = myModel(torch.tensor([words2vecs(seg_word(testStr2))], dtype=torch.float32)).detach().numpy()[0]#.argmax()\n",
    "c = myModel(torch.tensor([words2vecs(seg_word(testStr3))], dtype=torch.float32)).detach().numpy()[0]#.argmax()\n",
    "d = myModel(torch.tensor([words2vecs(seg_word(testStr4))], dtype=torch.float32)).detach().numpy()[0]#.argmax()\n",
    "a = (a * 100).astype('int')\n",
    "b = (b * 100).astype('int')\n",
    "c = (c * 100).astype('int')\n",
    "d = (d * 100).astype('int')\n",
    "\n",
    "f1 = {labels[i]: a[i] for i in range(4)}\n",
    "f2 = {labels[i]: b[i] for i in range(4)}\n",
    "f3 = {labels[i]: c[i] for i in range(4)}\n",
    "f4 = {labels[i]: d[i] for i in range(4)}\n",
    "\n",
    "plt.axis('off')\n",
    "fig, ax = plt.subplots(nrows=2, ncols=2)\n",
    "\n",
    "wc.generate_from_frequencies(f1)\n",
    "ax[0, 0].set_title(testStr)\n",
    "ax[0, 0].axis('off')\n",
    "ax[0, 0].imshow(wc)\n",
    "\n",
    "wc.generate_from_frequencies(f2)\n",
    "ax[0, 1].set_title(testStr2)\n",
    "ax[0, 1].axis('off')\n",
    "ax[0, 1].imshow(wc)\n",
    "\n",
    "wc.generate_from_frequencies(f3)\n",
    "ax[1, 0].set_title(testStr3)\n",
    "ax[1, 0].axis('off')\n",
    "ax[1, 0].imshow(wc)\n",
    "\n",
    "wc.generate_from_frequencies(f4)\n",
    "ax[1, 1].set_title(testStr4)\n",
    "ax[1, 1].axis('off')\n",
    "ax[1, 1].imshow(wc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 组内分工\n",
    "* RNN模型设计与训练、Transformer模型设计与训练、scrapy舆论爬取：黄奕铭\n",
    "* 自然语言数据预处理、sklearn词向量分析、rnn结果评估：刘佳琦\n",
    "* scrapy股票数据爬取、预训练数据处理、transformer结果评估：贾卓霖\n",
    "* mysql、scrapy pipeline数据存储、scrapy http封装：孙海川\n",
    "# 问题与反思\n",
    "* 疫情的原因，我无法使用实验室里的GPU，线上的GPU太贵了，像transformer这种模型一轮就是两瓶可乐而且我用只想用torch（比如百度的paddle每天免费的8个小时、google的colab也有免费的但是排队很多人）只跑了几轮\n",
    "![image-20220529201433280](index.assets/image-20220529201433280.png)\n",
    "* 学习率变化策略还可以改变\n",
    "* 时间序列问题，可以使用hmm模型进行推理\n",
    "* 情感分类的词嵌入模型可以找更好的\n",
    "* 情感分类的模型可以试用（pca后）的svm、决策树一类模型\n",
    "* 训练的时候还可以加点tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:root] *",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
